A storage system is a computer that provides storage services relating to the organization of information on writeable persistent storage devices, such as disks. The storage system may include a software component that functions as a server to manage and maintain up-to-date (current) information about the system. The information maintained by the server can be modeled as a set of objects, each of which contains a set of properties. Objects may be added or removed from the system, and the values of their properties may change over time.
The storage system may be further configured to operate according to a client/server model of information delivery to thereby allow many clients to access the objects served by the system. In this model, the client may comprise a software component, such a graphical user interface (GUI) process, executing on a computer that “connects” to the storage system over a computer network, such as a point-to-point link, a shared local area network, a wide area network that may span long distances or a virtual private network implemented over a public network, such as the Internet. Each client may request the services of the server by issuing object access queries or requests to the storage system.
In response to a client issuing a request to access (e.g., read) the data of one or more objects, the server may send a latest image of the data for all of the objects. Depending on the number and type of objects, this could represent a substantial amount of data that consumes a substantial amount of resources (e.g., processor, memory and/or storage) on the storage system and on the network (bandwidth). In the latter case, the available bandwidth in the network may be limited and its usage may be expansive, while the latency of the network may be high (especially for long distances). Each client may disconnect and reconnect (either shortly thereafter or after a long pause), or never reconnect. Often the server may not know whether or when the client may reconnect. A disconnection may not necessarily be an orderly one, and may include an unplanned outage in the network, a failure in the client, etc.
Armed with the latest image of the object data, the client constructs a local copy of the information, including all existing objects and their relationships in the system, and may display this information to a user via, e.g., an associated GUI display. In response, the user may perform various filtering and navigation operations on the information in a local, high-responsiveness fashion, without requiring interaction with the server. The user typically expects the displayed information to be current, such that if new objects are is added (e.g., by a different client) or changed, the client reflects such additions or changes in a timely manner (e.g., 10 seconds). Accordingly, a basic implementation could be for the client to query the server, e.g., on the order of every 10 seconds, for the entire information about the objects and their structural properties. Since the number of objects is large, this would lead to excessive and impractical network utilization.
Since the server manages and maintains all information, some systems are configured such that the server performs most of the logic needed for each client to interact with its user. The server may even dictate the manner in which the information is presented on the display associated with the client. Although such configurations may lead to efficient network utilization, they may also overload the server with GUI related operation processing that may, in turn, cause a scalability bottleneck. Furthermore, various GUI operations may be slow and/or lengthy due to inherent network latency, resulting in adverse (degraded) user interaction/responsiveness.
A different approach may offload such operation processing from the server to the client. Typically, this requires that the server propagate some portion of its managed information to the client via the network. The advantages of this approach include offloading of the processing effort and, for various operations, potentially faster responsiveness for a client user. Often, the client's local copy of the information is not fully up-to-date; however, this may be acceptable as long as the currency of the copy is reasonable. A disadvantage of this approach is the typically higher network utilization required to propagate the information to the client. This is particularly prominent in cases where the client requires certain information related to the entire managed system, and where the entire system's information is large.
Some systems address the issues described above by enabling the server to propagate only changes (delta) information to each client. To that end, these systems typically maintain a queue of information changes for each client and stream (transmit) that information to the client. The disadvantage of this approach is that the queues may grow in size. Furthermore, if a client disconnects, the server may either maintain the queues in the event the case the client reconnects or eventually destroy (cancel) the queues. If a client reconnects after a long pause, and its queues were cancelled, then synchronization is of the entire information from the server to the client is required.